/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('rai', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model BatchContentAsyncDetectRequest {
  regionId?: string(name='RegionId', example='cn-shanghai'),
  sceneName?: string(name='SceneName', example='""'),
  serviceName?: string(name='ServiceName', example='textDetection'),
  serviceParameterList?: [ 
    {
      content?: string(name='content', example='"XXXXXXXX"'),
    }
  ](name='serviceParameterList'),
}

model BatchContentAsyncDetectResponseBody = {
  code?: string(name='Code', example='00000'),
  data?: {
    taskId?: string(name='TaskId', example='19657954336'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='""'),
  requestId?: string(name='RequestId', example='9736C44E-F718-566B-821F-710216aAAAAAA-BBBB-CCCCC-DDDD-EEEEEEEE****F68692'),
  success?: boolean(name='Success', example='True'),
}

model BatchContentAsyncDetectResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: BatchContentAsyncDetectResponseBody(name='body'),
}

/**
 * @summary BatchContentAsyncDetect
 *
 * @param request BatchContentAsyncDetectRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return BatchContentAsyncDetectResponse
 */
async function batchContentAsyncDetectWithOptions(request: BatchContentAsyncDetectRequest, runtime: Util.RuntimeOptions): BatchContentAsyncDetectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.sceneName)) {
    query['SceneName'] = request.sceneName;
  }
  if (!Util.isUnset(request.serviceName)) {
    query['ServiceName'] = request.serviceName;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.serviceParameterList)) {
    body['serviceParameterList'] = request.serviceParameterList;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'BatchContentAsyncDetect',
    version = '2024-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary BatchContentAsyncDetect
 *
 * @param request BatchContentAsyncDetectRequest
 * @return BatchContentAsyncDetectResponse
 */
async function batchContentAsyncDetect(request: BatchContentAsyncDetectRequest): BatchContentAsyncDetectResponse {
  var runtime = new Util.RuntimeOptions{};
  return batchContentAsyncDetectWithOptions(request, runtime);
}

model BatchContentSyncDetectRequest {
  regionId?: string(name='RegionId', example='cn-shanghai'),
  sceneName?: string(name='SceneName', example='""'),
  serviceName?: string(name='ServiceName', example='textDetection
imageDetection'),
  serviceParameterList?: [ 
    {
      content?: string(name='content'),
    }
  ](name='serviceParameterList'),
}

model BatchContentSyncDetectResponseBody = {
  code?: string(name='Code', example='00000'),
  data?: {
    detectResultList?: [ 
      {
        riskInfo?: string(name='RiskInfo'),
        riskResult?: int32(name='RiskResult', example='1'),
      }
    ](name='DetectResultList'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='""'),
  requestId?: string(name='RequestId', example='AAAAAA-BBBB-CCCCC-DDDD-EEEEEEEE****'),
  success?: boolean(name='Success', example='True'),
}

model BatchContentSyncDetectResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: BatchContentSyncDetectResponseBody(name='body'),
}

/**
 * @summary BatchContentSyncDetect
 *
 * @param request BatchContentSyncDetectRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return BatchContentSyncDetectResponse
 */
async function batchContentSyncDetectWithOptions(request: BatchContentSyncDetectRequest, runtime: Util.RuntimeOptions): BatchContentSyncDetectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.sceneName)) {
    query['SceneName'] = request.sceneName;
  }
  if (!Util.isUnset(request.serviceName)) {
    query['ServiceName'] = request.serviceName;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.serviceParameterList)) {
    body['serviceParameterList'] = request.serviceParameterList;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'BatchContentSyncDetect',
    version = '2024-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary BatchContentSyncDetect
 *
 * @param request BatchContentSyncDetectRequest
 * @return BatchContentSyncDetectResponse
 */
async function batchContentSyncDetect(request: BatchContentSyncDetectRequest): BatchContentSyncDetectResponse {
  var runtime = new Util.RuntimeOptions{};
  return batchContentSyncDetectWithOptions(request, runtime);
}

model CheckAccountRequest {
  regionId?: string(name='RegionId', example='cn-shanghai'),
}

model CheckAccountResponseBody = {
  code?: string(name='Code', example='00000'),
  data?: {
    checkResult?: int32(name='CheckResult', example='1'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='""'),
  requestId?: string(name='RequestId', example='AAAAAA-BBBB-CCCCC-DDDD-EEEEEEEE****'),
  success?: boolean(name='Success', example='True'),
}

model CheckAccountResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CheckAccountResponseBody(name='body'),
}

/**
 * @summary 检查用户是否开通RAI服务
 *
 * @param request CheckAccountRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return CheckAccountResponse
 */
async function checkAccountWithOptions(request: CheckAccountRequest, runtime: Util.RuntimeOptions): CheckAccountResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CheckAccount',
    version = '2024-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 检查用户是否开通RAI服务
 *
 * @param request CheckAccountRequest
 * @return CheckAccountResponse
 */
async function checkAccount(request: CheckAccountRequest): CheckAccountResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkAccountWithOptions(request, runtime);
}

model ContentAsyncDetectRequest {
  regionId?: string(name='RegionId', example='cn-shanghai'),
  sceneName?: string(name='SceneName', example='""'),
  serviceName?: string(name='ServiceName', example='textDetection'),
  serviceParameter?: {
    content?: string(name='content'),
  }(name='serviceParameter'),
}

model ContentAsyncDetectResponseBody = {
  code?: string(name='Code', example='00000'),
  data?: {
    taskId?: string(name='TaskId', example='5d85cd38-03b2-49fd-86b2-be85c4b13215'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='""'),
  requestId?: string(name='RequestId', example='AAAAAA-BBBB-CCCCC-DDDD-EEEEEEEE****'),
  success?: boolean(name='Success', example='True'),
}

model ContentAsyncDetectResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ContentAsyncDetectResponseBody(name='body'),
}

/**
 * @summary ContentAsyncDetect
 *
 * @param request ContentAsyncDetectRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ContentAsyncDetectResponse
 */
async function contentAsyncDetectWithOptions(request: ContentAsyncDetectRequest, runtime: Util.RuntimeOptions): ContentAsyncDetectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.sceneName)) {
    query['SceneName'] = request.sceneName;
  }
  if (!Util.isUnset(request.serviceName)) {
    query['ServiceName'] = request.serviceName;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.serviceParameter)) {
    body['serviceParameter'] = request.serviceParameter;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ContentAsyncDetect',
    version = '2024-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary ContentAsyncDetect
 *
 * @param request ContentAsyncDetectRequest
 * @return ContentAsyncDetectResponse
 */
async function contentAsyncDetect(request: ContentAsyncDetectRequest): ContentAsyncDetectResponse {
  var runtime = new Util.RuntimeOptions{};
  return contentAsyncDetectWithOptions(request, runtime);
}

model ContentSyncDetectRequest {
  regionId?: string(name='RegionId', example='cn-shanghai'),
  sceneName?: string(name='SceneName', example='""'),
  serviceName?: string(name='ServiceName', example='textDetection'),
  serviceParameter?: {
    content?: string(name='content'),
  }(name='serviceParameter'),
}

model ContentSyncDetectResponseBody = {
  code?: string(name='Code', example='00000'),
  data?: {
    riskInfo?: string(name='RiskInfo'),
    riskResult?: int32(name='RiskResult', example='1'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='""'),
  requestId?: string(name='RequestId', example='AAAAAA-BBBB-CCCCC-DDDD-EEEEEEEE****'),
  success?: boolean(name='Success', example='True'),
}

model ContentSyncDetectResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ContentSyncDetectResponseBody(name='body'),
}

/**
 * @summary ContentSyncDetect
 *
 * @param request ContentSyncDetectRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ContentSyncDetectResponse
 */
async function contentSyncDetectWithOptions(request: ContentSyncDetectRequest, runtime: Util.RuntimeOptions): ContentSyncDetectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.sceneName)) {
    query['SceneName'] = request.sceneName;
  }
  if (!Util.isUnset(request.serviceName)) {
    query['ServiceName'] = request.serviceName;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.serviceParameter)) {
    body['serviceParameter'] = request.serviceParameter;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ContentSyncDetect',
    version = '2024-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'json',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary ContentSyncDetect
 *
 * @param request ContentSyncDetectRequest
 * @return ContentSyncDetectResponse
 */
async function contentSyncDetect(request: ContentSyncDetectRequest): ContentSyncDetectResponse {
  var runtime = new Util.RuntimeOptions{};
  return contentSyncDetectWithOptions(request, runtime);
}

model GetContentDetectResultRequest {
  regionId?: string(name='RegionId', example='cn-shanghai'),
  taskId?: string(name='TaskId', example='5d85cd38-03b2-49fd-86b2-be85c4b13215'),
}

model GetContentDetectResultResponseBody = {
  code?: string(name='Code', example='00000'),
  data?: {
    detectResultList?: [ 
      {
        riskInfo?: string(name='RiskInfo'),
        riskResult?: int32(name='RiskResult', example='1'),
        status?: int32(name='Status', example='2'),
      }
    ](name='DetectResultList'),
    processedCount?: int32(name='ProcessedCount', example='10'),
    taskId?: string(name='TaskId'),
    taskStatus?: int32(name='TaskStatus', example='2'),
    totalCount?: int32(name='TotalCount', example='10'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='""'),
  requestId?: string(name='RequestId', example='AAAAAA-BBBB-CCCCC-DDDD-EEEEEEEE****'),
  success?: boolean(name='Success', example='True'),
}

model GetContentDetectResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetContentDetectResultResponseBody(name='body'),
}

/**
 * @summary GetContentDetectResult
 *
 * @param request GetContentDetectResultRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return GetContentDetectResultResponse
 */
async function getContentDetectResultWithOptions(request: GetContentDetectResultRequest, runtime: Util.RuntimeOptions): GetContentDetectResultResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetContentDetectResult',
    version = '2024-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary GetContentDetectResult
 *
 * @param request GetContentDetectResultRequest
 * @return GetContentDetectResultResponse
 */
async function getContentDetectResult(request: GetContentDetectResultRequest): GetContentDetectResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return getContentDetectResultWithOptions(request, runtime);
}

model ListSensitiveWordRequest {
  pageNumber?: int32(name='PageNumber', example='1'),
  pageSize?: int32(name='PageSize', example='10'),
  regionId?: string(name='RegionId', example='cn-shanghai'),
}

model ListSensitiveWordResponseBody = {
  code?: string(name='Code', example='00000'),
  data?: {
    maxCount?: int32(name='MaxCount', example='10000'),
    pageNumber?: int32(name='PageNumber', example='1'),
    pageSize?: int32(name='PageSize', example='10'),
    sensitiveWordList?: [ 
      {
        id?: long(name='Id', example='387907'),
        label?: string(name='Label'),
        word?: string(name='Word'),
      }
    ](name='SensitiveWordList'),
    totalCount?: int32(name='TotalCount', example='100'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='""'),
  requestId?: string(name='RequestId', example='AAAAAA-BBBB-CCCCC-DDDD-EEEEEEEE****'),
  success?: boolean(name='Success', example='True'),
}

model ListSensitiveWordResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListSensitiveWordResponseBody(name='body'),
}

/**
 * @summary ListSensitiveWord
 *
 * @param request ListSensitiveWordRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return ListSensitiveWordResponse
 */
async function listSensitiveWordWithOptions(request: ListSensitiveWordRequest, runtime: Util.RuntimeOptions): ListSensitiveWordResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListSensitiveWord',
    version = '2024-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary ListSensitiveWord
 *
 * @param request ListSensitiveWordRequest
 * @return ListSensitiveWordResponse
 */
async function listSensitiveWord(request: ListSensitiveWordRequest): ListSensitiveWordResponse {
  var runtime = new Util.RuntimeOptions{};
  return listSensitiveWordWithOptions(request, runtime);
}

model RegisterAccountRequest {
  memo?: string(name='Memo', example='"user api register"'),
  regionId?: string(name='RegionId', example='cn-shanghai'),
}

model RegisterAccountResponseBody = {
  code?: string(name='Code', example='00000'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='""'),
  requestId?: string(name='RequestId', example='AAAAAA-BBBB-CCCCC-DDDD-EEEEEEEE****'),
  success?: boolean(name='Success', example='True'),
}

model RegisterAccountResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RegisterAccountResponseBody(name='body'),
}

/**
 * @summary 注册RAI账号
 *
 * @param request RegisterAccountRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return RegisterAccountResponse
 */
async function registerAccountWithOptions(request: RegisterAccountRequest, runtime: Util.RuntimeOptions): RegisterAccountResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.memo)) {
    query['Memo'] = request.memo;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RegisterAccount',
    version = '2024-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary 注册RAI账号
 *
 * @param request RegisterAccountRequest
 * @return RegisterAccountResponse
 */
async function registerAccount(request: RegisterAccountRequest): RegisterAccountResponse {
  var runtime = new Util.RuntimeOptions{};
  return registerAccountWithOptions(request, runtime);
}

model SyncSensitiveWordRequest {
  bodyData?: {
    sensitiveWordList?: [ 
      {
        id?: int32(name='Id', example='341806'),
        label?: string(name='Label'),
        status?: int32(name='Status'),
        word?: string(name='Word'),
      }
    ](name='SensitiveWordList'),
  }(name='BodyData'),
  commit?: boolean(name='Commit', example='true'),
  regionId?: string(name='RegionId', example='cn-shanghai'),
}

model SyncSensitiveWordShrinkRequest {
  bodyDataShrink?: string(name='BodyData'),
  commit?: boolean(name='Commit', example='true'),
  regionId?: string(name='RegionId', example='cn-shanghai'),
}

model SyncSensitiveWordResponseBody = {
  code?: string(name='Code', example='00000'),
  data?: {
    sensitiveWordErrorList?: [ 
      {
        errMessage?: string(name='ErrMessage', example='""'),
        errStatus?: int32(name='ErrStatus', example='1'),
        index?: long(name='Index', example='0'),
        label?: string(name='Label', example='contraband'),
        word?: string(name='Word'),
      }
    ](name='SensitiveWordErrorList'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode', example='200'),
  message?: string(name='Message', example='""'),
  requestId?: string(name='RequestId', example='AAAAAA-BBBB-CCCCC-DDDD-EEEEEEEE****'),
  success?: boolean(name='Success', example='True'),
}

model SyncSensitiveWordResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SyncSensitiveWordResponseBody(name='body'),
}

/**
 * @summary SyncSensitiveWord
 *
 * @param tmpReq SyncSensitiveWordRequest
 * @param runtime runtime options for this request RuntimeOptions
 * @return SyncSensitiveWordResponse
 */
async function syncSensitiveWordWithOptions(tmpReq: SyncSensitiveWordRequest, runtime: Util.RuntimeOptions): SyncSensitiveWordResponse {
  Util.validateModel(tmpReq);
  var request = new SyncSensitiveWordShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.bodyData)) {
    request.bodyDataShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.bodyData, 'BodyData', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.commit)) {
    query['Commit'] = request.commit;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.bodyDataShrink)) {
    body['BodyData'] = request.bodyDataShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SyncSensitiveWord',
    version = '2024-07-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

/**
 * @summary SyncSensitiveWord
 *
 * @param request SyncSensitiveWordRequest
 * @return SyncSensitiveWordResponse
 */
async function syncSensitiveWord(request: SyncSensitiveWordRequest): SyncSensitiveWordResponse {
  var runtime = new Util.RuntimeOptions{};
  return syncSensitiveWordWithOptions(request, runtime);
}

